Apprendre Ruby en 10 minutes

8 October 2025 — Langage De Programmation

Ruby est un langage de programmation dynamique et orienté objet connu pour sa syntaxe élégante et ses fonctionnalités conviviales pour les développeurs. Ce tutoriel couvre les concepts fondamentaux de Ruby pour vous aider à apprendre rapidement le langage.

1. Écrire votre premier programme Ruby

Commençons par un programme simple. Créez un fichier nommé hello.rb et entrez le code suivant :

puts "Hello, World!"

Sauvegardez le fichier et exécutez la commande suivante dans le terminal :

ruby hello.rb

La sortie sera :

Hello, World!

Ce programme simple démontre la fonctionnalité de sortie de base de Ruby. La méthode puts est utilisée pour afficher des informations textuelles dans la console.

2. Syntaxe de base

La syntaxe de Ruby est claire et lisible, conçue pour être naturelle et intuitive.

# Ceci est un commentaire
puts "Hello, World!"

Règles de syntaxe de base en Ruby :

Commentaires : Les commentaires sur une seule ligne commencent par #, tandis que les commentaires multi-lignes utilisent =begin et =end.
Instructions : Typiquement une instruction par ligne, pas besoin de point-virgule ; à la fin.
Blocs de code : Définis par do...end ou des accolades {}.
Appels de méthode : Les parenthèses sont optionnelles pour les appels de méthode sans arguments.

Exemple avec des commentaires multi-lignes :

=begin
Ceci est un commentaire multi-ligne,
s'étendant sur plusieurs lignes.
=end

3. Variables et types de données

En Ruby, les variables sont typées dynamiquement et ne nécessitent pas de déclarations de type explicites.

Règles de base pour nommer les variables :

Les noms de variables ne peuvent contenir que des lettres, des chiffres et des tirets bas.
Les noms de variables ne peuvent pas commencer par un chiffre.
Les noms de variables sont sensibles à la casse.
Les mots-clés Ruby ne peuvent pas être utilisés comme noms de variables.

Les principaux types de données de base en Ruby sont :

Entier (Integer) : par exemple, 42 ou -10.
Flottant (Float) : par exemple, 3.14 ou 2.5e3.
Chaîne (String) : par exemple, "hello" ou 'world', utilisant des guillemets simples ou doubles.
Booléen (Boolean) : true ou false.
Nil (Nil) : Représenté par nil, indiquant une valeur nulle ou aucune valeur.
Symbole (Symbol) : par exemple, :name, identifiants immuables.

3.1 Types numériques

Ruby supporte les entiers et les nombres à virgule flottante.

# Entier
age = 25
population = 1_000_000  # Tiret bas pour la lisibilité

# Flottant
temperature = 36.5
pi = 3.14159

# Opérations
puts 10 + 5   # 15
puts 10 / 3   # 3 (division entière)
puts 10.0 / 3 # 3.333... (division flottante)

3.2 Chaînes de caractères

Les chaînes sont des séquences de caractères, entourées de guillemets simples ou doubles.

single_quote = 'Chaîne avec guillemets simples'
double_quote = "Chaîne avec guillemets doubles"
multiline = "Ceci est une
chaîne multi-lignes"

# Interpolation de chaîne (uniquement dans les guillemets doubles)
name = "Alice"
greeting = "Hello, #{name}!"
puts greeting  # "Hello, Alice!"

Opérations sur les chaînes :

text = "Programmation Ruby"
puts text.length        # Longueur de la chaîne
puts text.upcase        # Convertir en majuscules
puts text.downcase      # Convertir en minuscules
puts text[0]            # Accéder au premier caractère
puts text[0..3]         # Découpage de chaîne
puts text.include?("Ruby")  # Vérifier l'inclusion

3.3 Type booléen

Le type booléen a deux valeurs : true et false.

is_active = true
is_complete = false

# Opérations booléennes
result1 = true && false  # false
result2 = true || false  # true
result3 = !true          # false

3.4 Type Nil

nil représente un état nul ou sans valeur.

value = nil

if value.nil?
  puts "La valeur est nulle"
end

3.5 Symbole

Les symboles sont des identifiants immuables, souvent utilisés comme clés dans les hachages.

:name
:email
:created_at

# Symboles vs Chaînes
puts :name.object_id == :name.object_id  # true (même objet)
puts "name".object_id == "name".object_id  # false (objets différents)

4. Structures de données

Ruby fournit plusieurs structures de données intégrées pour stocker et manipuler des données.

4.1 Tableau

Un tableau est une collection ordonnée qui peut contenir plusieurs valeurs.

numbers = [1, 2, 3, 4, 5]
numbers.push(6)        # Ajouter un élément
numbers.unshift(0)     # Insérer au début
numbers.delete(3)      # Supprimer une valeur spécifique
numbers[0] = 10        # Modifier un élément
puts numbers.inspect   # [10, 2, 4, 5, 6]

Opérations sur les tableaux :

numbers = [10, 20, 30, 40, 50]
puts numbers[1..3]     # [20, 30, 40]
puts numbers.first     # 10
puts numbers.last      # 50
puts numbers.include?(30)  # true

4.2 Hachage

Un hachage est une collection de paires clé-valeur, similaire aux dictionnaires dans d’autres langages.

student = {
  name: "John",
  age: 20,
  major: "Informatique"
}

# Accéder et modifier le hachage
puts student[:name]
student[:age] = 21
student[:gpa] = 3.8

# Itérer sur le hachage
student.each do |key, value|
  puts "#{key}: #{value}"
end

5. Contrôle de flux

Ruby fournit plusieurs instructions de contrôle de flux pour gérer l’exécution du programme.

5.1 Instructions if

L’instruction if évalue une condition et exécute son bloc si la condition est vraie.

age = 20
if age >= 18
  puts "Adulte"
elsif age >= 13
  puts "Adolescent"
else
  puts "Enfant"
end

# if sur une ligne
puts "Adulte" if age >= 18

5.2 Instructions unless

unless est l’opposé de if - s’exécute lorsque la condition est fausse.

age = 15
unless age >= 18
  puts "Pas adulte"
end

# unless sur une ligne
puts "Pas adulte" unless age >= 18

5.3 Instructions case

Les instructions case fournissent un moyen propre de gérer plusieurs conditions.

grade = "B"

case grade
when "A"
  puts "Excellent"
when "B"
  puts "Bon"
when "C"
  puts "Moyen"
else
  puts "Besoin d'amélioration"
end

5.4 Boucles

Ruby supporte diverses constructions de boucles.

Boucle while :

count = 0
while count < 5
  puts count
  count += 1
end

Boucle until :

count = 0
until count >= 5
  puts count
  count += 1
end

Boucle for :

for i in 0..4
  puts i
end

Itérateur each :

(0..4).each do |i|
  puts i
end

# Avec des tableaux
fruits = ["pomme", "banane", "cerise"]
fruits.each do |fruit|
  puts fruit
end

break et next :

(0..9).each do |i|
  break if i == 5     # Sortir de la boucle
  next if i % 2 == 0  # Sauter les nombres pairs
  puts i              # Sortie : 1, 3
end

6. Méthodes

Les méthodes en Ruby sont définies en utilisant le mot-clé def.

Définition de méthode de base :

def greet(name)
  "Hello, #{name}!"
end

# Appel de la méthode
message = greet("John")
puts message

Paramètres par défaut :

def greet(name, greeting = "Hello")
  "#{greeting}, #{name}!"
end

puts greet("Alice")          # "Hello, Alice!"
puts greet("Bob", "Hi")      # "Hi, Bob!"

Arguments variables :

def sum_numbers(*numbers)
  numbers.sum
end

puts sum_numbers(1, 2, 3, 4)  # 10

Arguments par mot-clé :

def create_person(name:, age:, city: "Unknown")
  { name: name, age: age, city: city }
end

person = create_person(name: "Alice", age: 25)
puts person.inspect

7. Blocs et Procs

Les blocs sont des morceaux de code qui peuvent être passés aux méthodes.

Utilisation des blocs :

# Utilisation de do...end
3.times do
  puts "Hello!"
end

# Utilisation d'accolades
3.times { puts "Hello!" }

# Blocs avec paramètres
(1..3).each do |number|
  puts "Number: #{number}"
end

Mot-clé Yield :

def run_block
  puts "Avant le bloc"
  yield
  puts "Après le bloc"
end

run_block { puts "Dans le bloc" }

Procs :

Les Procs sont des objets qui encapsulent des blocs.

square = Proc.new { |x| x * x }
puts square.call(5)  # 25

# Passer des procs aux méthodes
def apply_operation(numbers, operation)
  numbers.map { |n| operation.call(n) }
end

numbers = [1, 2, 3, 4]
squares = apply_operation(numbers, square)
puts squares.inspect  # [1, 4, 9, 16]

8. Classes et objets

Ruby est un langage purement orienté objet où tout est un objet.

Définition de classe de base :

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end

  def introduce
    "Je suis #{@name}, #{@age} ans"
  end

  def have_birthday
    @age += 1
    "#{@name} a eu un anniversaire, maintenant #{@age} ans"
  end
end

# Création d'objets
person1 = Person.new("John", 25)
person2 = Person.new("Jane", 30)

puts person1.introduce
puts person2.have_birthday

Méthodes d’accès :

class Person
  attr_reader :name    # Accès en lecture
  attr_writer :age     # Accès en écriture
  attr_accessor :city  # Accès en lecture et écriture

  def initialize(name, age, city)
    @name = name
    @age = age
    @city = city
  end
end

person = Person.new("Alice", 25, "New York")
puts person.name      # "Alice"
person.age = 26       # Définir l'âge
person.city = "Boston" # Définir la ville
puts person.city      # "Boston"

Méthodes de classe et variables :

class Student
  @@student_count = 0  # Variable de classe

  def initialize(name)
    @name = name
    @@student_count += 1
  end

  def self.student_count  # Méthode de classe
    @@student_count
  end
end

student1 = Student.new("John")
student2 = Student.new("Jane")
puts Student.student_count  # 2

Héritage :

class Animal
  def initialize(name)
    @name = name
  end

  def speak
    "#{@name} fait un bruit"
  end
end

class Dog < Animal
  def speak
    "#{@name} aboie"
  end
end

class Cat < Animal
  def speak
    "#{@name} miaule"
  end
end

dog = Dog.new("Buddy")
cat = Cat.new("Mimi")

puts dog.speak  # "Buddy aboie"
puts cat.speak  # "Mimi miaule"

9. Modules et Mixins

Les modules sont utilisés pour regrouper des méthodes et constantes apparentées, et peuvent être mélangés dans des classes.

Définition de module :

module Speakable
  def speak
    "#{@name} dit quelque chose"
  end
end

class Person
  include Speakable

  def initialize(name)
    @name = name
  end
end

person = Person.new("Alice")
puts person.speak  # "Alice dit quelque chose"

Espaces de noms avec modules :

module Math
  PI = 3.14159

  def self.square(x)
    x * x
  end
end

puts Math::PI        # 3.14159
puts Math.square(5)  # 25

10. Gestion des exceptions

Ruby fournit une gestion robuste des exceptions en utilisant begin, rescue, ensure et raise.

Gestion des exceptions de base :

begin
  result = 10 / 0
rescue ZeroDivisionError => e
  puts "Impossible de diviser par zéro : #{e.message}"
else
  puts "Division réussie"
ensure
  puts "Ceci s'exécute toujours"
end

Lever des exceptions :

def divide(a, b)
  raise "Impossible de diviser par zéro" if b == 0
  a / b
end

begin
  result = divide(10, 0)
rescue => e
  puts "Erreur : #{e.message}"
end

11. Opérations sur les fichiers

Ruby fournit des méthodes simples pour lire et écrire des fichiers.

Lecture de fichiers :

# Lire le fichier entier
content = File.read("example.txt")
puts content

# Lire ligne par ligne
File.foreach("example.txt") do |line|
  puts line.chomp
end

Écriture de fichiers :

# Écrire dans un fichier
File.write("output.txt", "Hello, Ruby!\n")

# Ajouter à un fichier
File.open("output.txt", "a") do |file|
  file.puts "Ajout de nouveau contenu."
end

12. Méthodes intégrées utiles

Ruby vient avec de nombreuses méthodes intégrées utiles.

Méthodes de chaîne :

text = "  Programmation Ruby  "
puts text.strip        # Supprimer les espaces
puts text.split(" ")   # Diviser en tableau
puts text.gsub("Ruby", "Python")  # Remplacer

Méthodes de tableau :

numbers = [3, 1, 4, 1, 5, 9, 2]
puts numbers.sort.inspect      # [1, 1, 2, 3, 4, 5, 9]
puts numbers.uniq.inspect      # [3, 1, 4, 5, 9, 2]
puts numbers.select { |n| n > 3 }.inspect  # [4, 5, 9]

Méthodes de hachage :

person = { name: "Alice", age: 25, city: "New York" }
puts person.keys.inspect    # [:name, :age, :city]
puts person.values.inspect  # ["Alice", 25, "New York"]
puts person.has_key?(:age)  # true

13. Ruby Gems

RubyGems est le gestionnaire de paquets de Ruby pour installer et gérer des bibliothèques.

Installation de gems :

gem install rails

Utilisation de gems dans le code :

require 'json'

# Analyser JSON
json_string = '{"name": "Alice", "age": 25}'
person = JSON.parse(json_string)
puts person["name"]  # "Alice"

# Générer JSON
person_hash = { name: "Bob", age: 30 }
json_output = JSON.generate(person_hash)
puts json_output  # {"name":"Bob","age":30}

14. Guide de style Ruby

Ruby a un guide de style communautaire fort qui promeut un code propre et lisible.

Indentation : Utilisez 2 espaces pour l’indentation.

Conventions de nommage :

Variables et méthodes : snake_case
Classes et modules : CamelCase
Constantes : SCREAMING_SNAKE_CASE

Parenthèses : Utilisez des parenthèses pour les appels de méthode avec arguments, omettez-les pour les appels de méthode sans arguments.

Blocs : Utilisez do...end pour les blocs multi-lignes, {} pour les blocs d’une seule ligne.

La syntaxe élégante et les fonctionnalités puissantes de Ruby en font un plaisir à utiliser. Son accent sur le bonheur et la productivité des développeurs l’a rendu populaire pour le développement web, les scripts et les tâches d’automatisation.